package com.aaa.stock.service.purch.impl;

import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.Snowflake;
import cn.hutool.core.util.IdUtil;
import com.aaa.entity.*;
import com.aaa.stock.dao.invent.InventoryDao;
import com.aaa.stock.dao.medic.MedicinesDao;
import com.aaa.stock.dao.purch.PurchaseDao;
import com.aaa.stock.dao.purch.PurchaseItemDao;
import com.aaa.stock.feign.UserFeign;
import com.aaa.stock.service.purch.PurchaseService;
import com.aaa.stock.vo.ExamineVo;
import com.aaa.stock.vo.PurchaseVo;
import com.aaa.utils.JwtUtil;
import com.aaa.utils.WebUtil;
import com.aaa.vo.Result;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;

@Service
public class PurchaseServiceImpl extends ServiceImpl<PurchaseDao,Purchase> implements PurchaseService {
    @Autowired
    private PurchaseDao purchaseDao;
    @Autowired
    private UserFeign userFeign;
    @Autowired
    private InventoryDao inventoryLogDao;
    @Autowired
    private PurchaseItemDao purchaseItemDao;
    @Autowired
    private MedicinesDao medicinesDao;

    @Override
    public Result<IPage<Purchase>> purchaseAll(Integer currentPage, Integer pageSize, PurchaseVo purchaseVo) {
        IPage<Purchase> page=new Page<>(currentPage,pageSize);
        QueryWrapper<Purchase> wrapper=new QueryWrapper<>();
        if(StringUtils.hasText(purchaseVo.getProviderId())){
            wrapper.like("provider_id",purchaseVo.getProviderId());
        }
        if(StringUtils.hasText(purchaseVo.getUserName())){
            wrapper.eq("apply_user_name",purchaseVo.getUserName());
        }
        if(Objects.nonNull(purchaseVo.getStatus())){
            wrapper.eq("status",purchaseVo.getStatus());
        }

        IPage<Purchase> page1 = purchaseDao.selectPage(page, wrapper);
        return new Result<IPage<Purchase>>(2000,"查询厂家成功",page1);
    }

    //作废、审核通过、提交审核
    @Override
    public Result<String> SubConPass(String status, List<Purchase> purchase) {
        // 取出当前的创建者
        HttpServletRequest request = WebUtil.getRequest();
        String token = request.getHeader("token");
        Map<String, Object> tokenData = JwtUtil.getTokenChaim(token);
        String phone = (String)tokenData.get("username");
        User user = userFeign.getByUsername(phone);
        String userName = user.getUserName();
        // 创建一个原子类
        AtomicInteger atomicInteger = new AtomicInteger();


        // 提交审核
        if(status.equals("2")){
            purchase.forEach(item->{
                if(item.getStatus().equals("2")){
                    // -1
                    atomicInteger.getAndDecrement();
                }else {
                    //判断状态是否未提交
                    if(item.getStatus().equals("1")){
                        //设置 提交状态
                        item.setStatus("2");
                        // 修改
                        try {
                            purchaseDao.modification(item.getStatus(),item.getPurchaseId());


                        }catch(Exception e) {
                            System.out.println("e = " + "修改异常");
                        }
                        atomicInteger.getAndIncrement();
                    }
                }
            });
            System.out.println("atomicInteger = " + atomicInteger.get());
            if(atomicInteger.get()==-1){ // 提交审核失败 该单已经提交审核
                return new Result(2000,"提交审核失败，该单已经待审核",atomicInteger);
            }else if (atomicInteger.get()==0){ // 作废失败  审核未通过
                return new Result(2000,"提交审核失败,该单不是未提交状态",atomicInteger);
            }else { // 入库成功
                if(atomicInteger.get()==1){
                    return new Result(2000,"提交审核成功",atomicInteger);
                }
            }

        }
        // 作废
        if(status.equals("5")){
            purchase.forEach(item->{
                String status1 = item.getStatus();
                if(status1.equals("5")){
                    // 减一
                    atomicInteger.decrementAndGet();
                }else {
                    if (status1.equals("4")||status1.equals("1")){
                        //设置 提交状态
                        item.setStatus("5");
                        // 修改
                        int i =  purchaseDao.modification(item.getStatus(), item.getPurchaseId());
                        if (i==1){
                            atomicInteger.getAndIncrement();
                        }
                    }
                }
            });
            if(atomicInteger.get()==-1){ // 作废失败 已经入库
                return new Result(2000,"作废失败，该单已经作废",atomicInteger);
            }else if (atomicInteger.get()==0){ // 作废失败  审核未通过
                return new Result(2000,"作废失败,该单不是未提交或审核失败",atomicInteger);
            }else { // 入库成功
                if(atomicInteger.get()==1){
                    return new Result(2000,"作废成功",atomicInteger);
                }
            }
        }

        // 提交入库
        // 判断入库按钮
        if(status.equals("6")){

            purchase.forEach(item->{
                String status1 = item.getStatus();
                // 判断状态是否为以入库
                if(status1.equals("6")){
                    // 减一
                    atomicInteger.decrementAndGet();
                }else {
                    // 判断是否为 审核通过
                    if (status1.equals("3")) {
                        //设置 提交入库状态
                        item.setStatus("6");
                        // 修改 采购单
                        int i = purchaseDao.modification(item.getStatus(), item.getPurchaseId());
                        /*用制单id查询出来 详情采购单中的 药品id*/
                        // 感觉采购号（制单号） id 查询出有多少药品 添加入库详情表
                        // 获取区制单号
                        String purchaseId = item.getPurchaseId();
                        // 查询出该制单号的所有药品
                        QueryWrapper<PurchaseItem> queryWrapper = new QueryWrapper<>();
                        queryWrapper.eq("purchase_id", purchaseId);
                        List<PurchaseItem> purchaseItems = purchaseItemDao.selectList(queryWrapper);
                        //拿到 该制单号的所有药品  foreach 遍历
                        purchaseItems.forEach(item1 ->{
                            // 提交入库
                            // 创建一个 实体类（入库详情表）
                            InventoryLog inventoryLog = new InventoryLog();
                            //生成 19 位id （生成 入库ID）
                            Snowflake snowflake = IdUtil.getSnowflake(1, 1);
                            long id = snowflake.nextId();
                            //存入入库 id   不重复
                            String s = Convert.toStr(id);
                            inventoryLog.setInventoryLogId(s);
                            // 存入采购单据id（制单号id ） PurchaseItem也有但是害怕重复
                            inventoryLog.setPurchaseId(item.getPurchaseId());
                            // 存入 药品 id
                            inventoryLog.setMedicinesId(item1.getMedicinesId());
                            // 存入 入库数量
                            inventoryLog.setInventoryLogNum(item1.getPurchaseNumber());
                            //存入 批发价格
                            inventoryLog.setTradePrice(item1.getTradePrice());
                            // 存入 处方价 （不是我存的）
                            // 存入 批发额
                            inventoryLog.setTradeTotalAmount(item1.getTradeTotalAmount());
                            // 存入 处方额 （不是我存的）
                            // 存入 药品生产批次号
                            inventoryLog.setBatchNumber(item1.getBatchNumber());
                            // 存入 药品名称
                            inventoryLog.setMedicinesName(item1.getMedicinesName());
                            // 存入 药品分类
                            inventoryLog.setMedicinesType(item1.getMedicinesType());
                            // 存入 处方类型
                            inventoryLog.setPrescriptionType(item1.getPrescriptionType());
                            //存入 生产厂家id
                            inventoryLog.setProducterId(item1.getProducerId());
                            // 存入 换算量
                            inventoryLog.setConversion(item1.getConversion());
                            // 存入  供应商id (purchase)
                            inventoryLog.setProviderId(item.getProviderId());
                            // 存入 创建时间  （当前时间）
                            inventoryLog.setCreateTime(LocalDateTime.now());
                            // 存入 创建者 （token）
                            inventoryLog.setCreateBy(userName);

                            // 添加 入库表
                            int insert = inventoryLogDao.insert(inventoryLog);

                            // 添加 库存    Medicines
                            QueryWrapper<Medicines> queryWrapper1 = new QueryWrapper<>();
                            queryWrapper1.eq("medicines_id",item1.getMedicinesId());
//查询出来 该id的实体类
                            Medicines medicines = medicinesDao.selectOne(queryWrapper1);
                            Integer purchaseNumber = item1.getPurchaseNumber();
                            //integer装换为bigDecimal
                            BigDecimal big2 = new BigDecimal(purchaseNumber.toString());
                            // 取出之前的库存
                            BigDecimal bigDecimal = big2.add(medicines.getMedicinesStockNum());
                            // 设置 库存
                            medicines.setMedicinesStockNum(bigDecimal);
                            // 设置更新时间
                            medicines.setUpdateTime(LocalDateTime.now());
                            // 修改 实体类
                            medicinesDao.updateById(medicines);
                        });


                        if (i == 1) {
                            atomicInteger.getAndIncrement();
                        }
                    }
                }
            });

            if(atomicInteger.get()==-1){ // 入库失败 已经入库
                return new Result(2000,"入库失败，该单已经入库",atomicInteger);
            }else if (atomicInteger.get()==0){ // 入库失败  审核未通过
                return new Result(2000,"入库失败,该单审核未通过",atomicInteger);
            }else { // 入库成功
                if(atomicInteger.get()==1){
                    return new Result(2000,"入库成功",atomicInteger);
                }
            }
        }
        return new Result(5000,"当前状态异常");
    }

    @Override
    public Result<String> newPurQuery() {
        //生成单据号
        long purchaseId=IdUtil.getSnowflakeNextId();
        String head="CG";
        //拼接
        String concat=head.concat(String.valueOf(purchaseId));
        return new Result<>(2000,"生成成功",concat);
    }

    @Override
    public Result<String> ItemPass(String status, String purchaseId) {
        QueryWrapper<Purchase> queryWrapper = new QueryWrapper<Purchase>();
        queryWrapper.eq("purchase_id",purchaseId);
        Purchase purchase = purchaseDao.selectOne(queryWrapper);
        String status1 = purchase.getStatus();

        if(status.equals("3")){
            if(status1.equals("3")){
                return new Result(2000,"该单 已经通过审核",0);

            }else {
                int i = purchaseDao.modification(status,purchaseId);
                if(i==1){
                    return new Result(2000,"该单 审核通过",i);
                }

                return new Result(2000,"该单 审核未成功",i);
            }
        }


        return new Result(5000,"服务器异常",0);

    }
//审核不通过
    @Override
    public Result<String> ItemNoPass(String status, String purchaseId, String examine) {
        QueryWrapper<Purchase> queryWrapper = new QueryWrapper<Purchase>();
        queryWrapper.eq("purchase_id",purchaseId);
        Purchase purchase = purchaseDao.selectOne(queryWrapper);
        String status1 = purchase.getStatus();
        if(status.equals("4")){
            if(status1.equals("4")){
                return new Result(2000,"该单 已经审核不通过",0);
            }else {
                int i = purchaseDao.modificationE(status,purchaseId,examine);
                if (i == 1) {
                    return new Result(2000, "（审核不通过）审核成功", i);
                }

                return new Result(2000, "（审核不通过） 审核未成功", i);
            }
        }

        return new Result(5000,"当前状态异常");
    }
}
